// dh-staff_users 云对象 - 员工用户管理
const db = uniCloud.database();
const _ = db.command;
const { autoMountHospitalId, softDelete, batchSoftDelete, getUserById, listStuffs } = require('dh-common');

/**
 * 统一响应格式化辅助函数
 */
function formatResponse(code, data = null, message = 'success', extraFields = {}) {
	return {
		code,
		data,
		message,
		success: (code === 200 || code === 201),
		timestamp: Date.now(),
		...extraFields
	};
}

/**
 * 统一错误响应辅助函数
 */
function formatError(error, defaultMessage = '操作失败') {
	console.error('[dh-staff_users] 错误:', error);
	return {
		code: 500,
		message: error.message || defaultMessage,
		success: false,
		timestamp: Date.now()
	};
}

/**
 * 解析JWT Token获取payload
 */
function parseToken(token) {
	if (!token || typeof token !== 'string') return null;
	try {
		const parts = token.split('.');
		if (parts.length !== 3) return null;
		// Base64解码payload部分
		const payload = Buffer.from(parts[1], 'base64').toString('utf-8');
		return JSON.parse(payload);
	} catch (error) {
		console.error('[dh-staff_users] 解析token失败:', error);
		return null;
	}
}

/**
 * 获取员工类型文本
 */
function getStaffTypeText(staffType) {
	const typeMap = {
		0: '行政',
		1: '采购',
		2: '财务',
		3: '院领导'
	};
	return typeMap[staffType] || '未知';
}

/**
 * 从 dh-common 获取员工姓名并附加类型信息
 */
async function enrichStaffInfo(staffData) {
	if (!staffData || !staffData.user_id) {
		return staffData;
	}
	
	try {
		// 使用统一的用户查询工具获取用户信息（自动解密）
		// getUserById 已经通过 matchesRoleFilter 检查了角色（staff等角色优先级 > 0，会通过检查）
		const userInfo = await getUserById(staffData.user_id, 'default', false, true);
		
		if (userInfo) {
			const realName = userInfo.realName || userInfo.displayName || '未知';
			const staffTypeText = getStaffTypeText(staffData.staff_type);
			
			return {
				...staffData,
				staff_name: realName,
				staff_type_text: staffTypeText
			};
		}
		
		// 如果获取用户信息失败，返回默认值
		return {
			...staffData,
			staff_name: '未知',
			staff_type_text: getStaffTypeText(staffData.staff_type)
		};
	} catch (error) {
		console.error('[enrichStaffInfo] 获取员工信息失败:', error);
		// 出现异常时，返回默认值
		return {
			...staffData,
			staff_name: '未知',
			staff_type_text: getStaffTypeText(staffData.staff_type)
		};
	}
}

/**
 * 批量附加员工信息
 */
async function enrichStaffList(staffList) {
	if (!Array.isArray(staffList) || staffList.length === 0) {
		return staffList;
	}
	
	// 获取所有唯一的用户ID
	const userIds = [...new Set(staffList.map(s => s.user_id).filter(Boolean))];
	
	if (userIds.length === 0) return staffList;
	
	try {
		// 使用dh-common模块查询员工列表
		const staffsResult = await listStuffs({ limit: 1000 });
		
		// 检查查询结果
		if (staffsResult.code !== 200) {
			console.warn(`[enrichStaffList] 查询员工列表失败: ${staffsResult.message}`);
			throw new Error(staffsResult.message);
		}
		
		// 过滤出我们需要的员工
		const staffs = staffsResult.data.filter(staff => userIds.includes(staff._id));
		
		// 构建用户ID到姓名的映射
		const staffMap = {};
		staffs.forEach(staff => {
			staffMap[staff._id] = staff.realName || staff.displayName || '未知';
		});
		
		// 附加员工姓名和类型
		return staffList.map(staff => ({
			...staff,
			staff_name: staffMap[staff.user_id] || '未知',
			staff_type_text: getStaffTypeText(staff.staff_type)
		}));
	} catch (error) {
		console.error('[enrichStaffList] 批量获取员工信息失败:', error);
		return staffList.map(staff => ({
			...staff,
			staff_name: '未知',
			staff_type_text: getStaffTypeText(staff.staff_type)
		}));
	}
}

module.exports = {

	/**
	 * 请求前拦截
	 */
	async _before(methodName, params) {
		// 获取客户端信息
		const clientInfo = this.getClientInfo();
		
		// 从clientInfo中获取token字符串并解析
		const tokenString = clientInfo?.uniIdToken;
		const tokenPayload = parseToken(tokenString);

		const writeMethods = ['create', 'update', 'delete', 'batch'];
		if (methodName && writeMethods.some(method => methodName.toLowerCase().includes(method))) {
			if (!tokenPayload?.uid) {
				throw new Error('401|未授权的访问');
			}
		}

		if (params && typeof params === 'object') {
			for (let key in params) {
				if (typeof params[key] === 'string') {
					params[key] = params[key].trim();
				}
			}
		}
	},

	/**
	 * 获取可用的员工用户列表（未创建员工信息的员工角色用户）
	 */
	async getAvailableStaffUsers() {
		try {
			// 1. 获取所有已有员工档案的用户ID
			const staffRes = await db.collection('dh-staff_users')
				.where({
					is_deleted: _.neq(true)
				})
				.field({
					user_id: true
				})
				.get();
			
			const existingUserIds = staffRes.data.map(s => s.user_id);
			
			// 2. 使用dh-common模块查询所有员工
			const staffsResult = await listStuffs({ limit: 1000 });
			
			// 检查查询结果
			if (staffsResult.code !== 200) {
				return formatResponse(500, null, `查询员工列表失败: ${staffsResult.message}`);
			}
			
			// 3. 过滤掉已有员工档案的用户
			let availableUsers = staffsResult.data.filter(user => !existingUserIds.includes(user._id));
			
			return formatResponse(200, availableUsers, '查询成功');
		} catch (error) {
			return formatError(error, '获取可用员工用户列表失败');
		}
	},

	async getStaffById(id) {
		try {
			if (!id) {
				return formatResponse(400, null, '员工ID不能为空');
			}

			const res = await db.collection('dh-staff_users').doc(id).get();
			if (res.data.length === 0) {
				return formatResponse(404, null, '员工不存在');
			}
			return formatResponse(200, res.data[0]);
		} catch (error) {
			return formatError(error, '获取员工失败');
		}
	},

	/**
	 * 获取员工用户详情（从 dh-staff_users 表）
	 * 关联 uni-id-users 表获取账户信息
	 */
	async getStaffUserById(id) {
		try {
			if (!id) {
				return formatResponse(400, null, '员工ID不能为空');
			}

			// 从 dh-staff_users 表查询员工信息
			const staffRes = await db.collection('dh-staff_users').doc(id).get();
			
			if (staffRes.data.length === 0) {
				return formatResponse(404, null, '员工不存在');
			}
			
			// 附加员工姓名和类型信息
			const enrichedStaff = await enrichStaffInfo(staffRes.data[0]);
			return formatResponse(200, enrichedStaff);
		} catch (error) {
			return formatError(error, '获取员工详情失败');
		}
	},

	/**
	 * 获取员工用户列表（从 dh-staff_users 表）
	 * 支持搜索员工姓名、部门、职位等
	 */
	async listStaffUsers(query = {}, skip = 0, limit = 20) {
		try {
			if (typeof query !== 'object' || query === null || Array.isArray(query)) {
				query = {};
			}
			skip = parseInt(skip) || 0;
			limit = parseInt(limit) || 20;
			
		// 构建查询条件
		let staffQuery = {
			is_deleted: false  // 默认不显示已删除记录
		};
		
		// 如果有搜索条件，添加到查询中
		if (query && Object.keys(query).length > 0) {
			staffQuery = { ...staffQuery, ...query };
		}
			
			// 查询总数
			const countRes = await db.collection('dh-staff_users')
				.where(staffQuery)
				.count();
			
			const totalCount = countRes.total || 0;
			
			// 从 dh-staff_users 表查询员工列表
			const staffRes = await db.collection('dh-staff_users')
				.where(staffQuery)
				.skip(skip)
				.limit(limit)
				.orderBy('create_time', 'desc')
				.get();
			
			// 批量附加员工姓名和类型信息
			const enrichedStaffs = await enrichStaffList(staffRes.data);
			
			return formatResponse(200, enrichedStaffs, 'success', { count: totalCount });
		} catch (error) {
			return formatError(error, '获取员工列表失败');
		}
	},

	async createStaff(data) {
		try {
			if (!data.user_id) {
				return formatResponse(400, null, '用户ID不能为空');
			}

			let staffData = {
				user_id: data.user_id,
				staff_type: data.staff_type !== undefined ? data.staff_type : 0,
				position: data.position || '',
				department: data.department || '',
				hire_date: data.hire_date || null,
				education_background: data.education_background || '',
				introduction: data.introduction || '',
				working_status: data.working_status !== undefined ? data.working_status : 0,
				is_active: data.is_active !== undefined ? data.is_active : true,
				is_deleted: false,  // 软删除字段，默认未删除
				create_time: Date.now(),
				update_time: Date.now()
			};
			
			// 如果有照片，添加photo字段
			if (data.photo) {
				staffData.photo = data.photo;
			}

			// 🏥 自动挂载医院ID（单一医院系统特性）
			staffData = await autoMountHospitalId(staffData);

			const res = await db.collection('dh-staff_users').add(staffData);
			return formatResponse(201, { _id: res.id }, '员工创建成功');
		} catch (error) {
			return formatError(error, '创建员工失败');
		}
	},

	async updateStaff(id, data) {
		try {
			if (!id) {
				return formatResponse(400, null, '员工ID不能为空');
			}

			const updateData = {
				...data,
				update_time: Date.now()
			};

			await db.collection('dh-staff_users').doc(id).update(updateData);
			return formatResponse(200, null, '员工信息更新成功');
		} catch (error) {
			return formatError(error, '更新员工失败');
		}
	},

	async deleteStaff(id, reason = '') {
		try {
			if (!id) {
				return formatResponse(400, null, '员工ID不能为空');
			}

			const uniIdToken = this.getUniIdToken();
			const result = await softDelete('dh-staff_users', id, uniIdToken?.uid || '', reason);
			
			if (result.code === 200) {
				return formatResponse(200, null, '员工已移至回收站');
			} else {
				return formatResponse(result.code, null, result.message);
			}
		} catch (error) {
			return formatError(error, '删除员工失败');
		}
	},

	async batchUpdateStaff(updates) {
		try {
			if (!Array.isArray(updates) || updates.length === 0) {
				return formatResponse(400, null, '更新数据不能为空');
			}

			const promises = updates.map(item =>
				db.collection('dh-staff_users').doc(item._id).update({
					...item,
					update_time: Date.now()
				})
			);

			await Promise.all(promises);
			return formatResponse(200, null, `批量更新${updates.length}条记录成功`);
		} catch (error) {
			return formatError(error, '批量更新失败');
		}
	},

	async batchDeleteStaff(ids, reason = '') {
		try {
			if (!Array.isArray(ids) || ids.length === 0) {
				return formatResponse(400, null, 'ID列表不能为空');
			}

			const uniIdToken = this.getUniIdToken();
			const result = await batchSoftDelete('dh-staff_users', ids, uniIdToken?.uid || '', reason);
			
			return formatResponse(result.code, result.data, result.message);
		} catch (error) {
			return formatError(error, '批量删除失败');
		}
	},

	async getStaffByHospital(hospitalId, skip = 0, limit = 20) {
		try {
			if (!hospitalId) {
				return formatResponse(400, null, '医院ID不能为空');
			}

			const res = await db.collection('dh-staff_users')
				.where({ hospital_id: hospitalId, is_active: true })
				.skip(skip)
				.limit(limit)
				.get();

			return formatResponse(200, res.data, 'success', { count: res.data.length });
		} catch (error) {
			return formatError(error, '获取医院员工失败');
		}
	},

	async getStaffByDepartment(hospitalId, department) {
		try {
			if (!hospitalId || !department) {
				return formatResponse(400, null, '医院ID和部门不能为空');
			}

			const res = await db.collection('dh-staff_users')
				.where({ hospital_id: hospitalId, department: department, is_active: true })
				.get();

			return formatResponse(200, res.data, 'success', { count: res.data.length });
		} catch (error) {
			return formatError(error, '获取部门员工失败');
		}
	}
};
